`scan_auth_credentials` and `scan_steam_id` ran byte-at-a-time loops
that scanned for a single anchor byte (`"`, `a`, `s`) and then compared
the following slice against the full needle. These functions run per
memory region over multi-gigabyte address space scans, so every
anchor-byte false positive paid for a full needle comparison.

Replace each loop with `memchr::memmem` (SIMD substring search).
Match positions and extraction bounds are unchanged.

One deliberate narrowing: the old loops resumed at `next + 1` and so
could match overlapping occurrences of a needle, while `find_iter`
resumes past the end of a match. Of the five needles only `"id":"`
has a self-border, and exercising the difference requires a buffer
holding the literal `"id":"id":"` followed by a valid account id. The
game's JSON cannot produce that, so the change is not observable.

memchr is already in Cargo.lock as a transitive dependency of
aho-corasick and regex, so depending on it directly leaves the
dependency tree and the resolved version untouched.

find_blob_end, blob_seed_offsets, and extract_blob_json searched
multi-megabyte inventory blobs with scalar `windows().position()`
loops. Swap these for memchr::memmem::find, which is SIMD-accelerated,
and use memchr::memchr for the single-byte closing-brace scan in
find_blob_end.

extract_blob_json's start-marker re-scan now reuses the existing
START_MARKER constant instead of a duplicate local one, since both
searched for the same bytes.

enclosing_object_start stays a manual backward loop: it counts brace
depth to find the *enclosing* `{`, not the last occurrence of a byte,
so memrchr does not apply.

Two of the converted sites were unpinned: the `.or_else` marker
priority (the existing assertion held for either branch) and the
extract_blob_json path that reinstates a missing opening brace. Both
now have exact-offset assertions, so a drift in search order or offset
arithmetic fails the harness.

parse_full_account_blob aggregated Upgrades/RawUpgrades/FlavourItems/
WeaponSkins into hash maps via entry(it.to_string()), which allocates
a String on every one of thousands of entries even though these
sections are dominated by duplicate keys. Check get_mut first and
only allocate on first insert.

Each ~10s scan cycle rebuilds BlobInventory's HashMaps/Vecs from a
multi-megabyte JSON tree, even though inventory changes maybe once
per mission, so almost every parse was wasted.

Add LAST_BLOB_DIGEST beside the existing LAST_BLOB_REGION address
cache, and blob_unchanged() to compare a candidate blob's bytes
against the last one seen. Check-and-update in a single call keeps
each of the three call sites (fast-path re-probe, full-walk
completion, full-walk immediate hit) one early-exit instead of
separate check and update steps. The digest is recorded before the
parse outcome is known, so every parse-failure path drops the
baseline via forget_blob_digest(); otherwise persistent unparseable
bytes would read as a cached success and stall the walk until the
PID changed.

On a hit, the scan is dropped without parsing or sending to blob_tx.
The UI already tolerates a cycle producing nothing and keeps its
last-known state, so the "Inventory Loaded" badge now appears when
the inventory actually changed rather than every 10s. The skip is
gated on `!save`, matching the existing fast-path convention, so an
explicit debug dump still writes the file even when the blob hasn't
moved. reset_last_blob_region() also clears the digest so a PID
change forces a re-parse.

extract_blob_json always copied the blob region into a fresh Vec,
even in the common case where the buffer still starts with the
original `{` and the bytes could be returned as a slice. For
multi-megabyte scan buffers this is a needless memcpy on every parse.

Add extract_blob_json_ref, returning Cow<[u8]>: Cow::Borrowed when
the opening brace survived, Cow::Owned only in the fallback path
where it was overwritten and has to be reinstated.
extract_blob_json is now a thin extract_blob_json_ref(..).into_owned()
wrapper, so its signature and behavior are unchanged for existing
callers.

parse_full_account_blob already computes end_pos via find_blob_end
for its size check, then extract_blob_json used to redo that scan
and re-locate the start marker. Factor the shared body into
extract_blob_json_at(raw, end_pos), taking the bound as a parameter,
and have parse_full_account_blob call it directly with the end_pos
it already has.

`blob_unchanged` hashed the whole buffer it was handed, and all three
callers hand it a stitched one. The stitch stops at the region that closes
the JSON but keeps everything after the closing brace, which is whatever
heap shares that region: tens of megabytes of it, rewritten constantly by
a running client.

The digest therefore changed on every scan of a completely settled
inventory, so the skip never fired once and every cycle reparsed. Hashing
now stops at `find_blob_end`, which also means hashing a few MB rather
than the whole read. Buffers with no blob end are hashed whole; they are
not blob data and only need to compare equal to themselves.

The existing fixtures could not catch this. Both carry no `DeathSquadable`
key and no trailing bytes, so they exercise only the whole-buffer path.

The digest tests also reset a process-global static and then assert
against it while running in parallel, so they could already clobber each
other. They share a mutex now.

The blob qualification runs six needles over every committed region, and
the end-marker check runs over the whole pending scan buffer. Those were
still scalar `windows().any()` passes while the rest of the scanner had
moved to `memmem`, so they fell back to a byte-at-a-time compare on
buffers measured in tens of megabytes.

`memmem::find(..).is_some()` matches the old semantics on short slices
too: a haystack shorter than the needle yields no windows and no match.

A freed copy of the FULL_ACCOUNT blob can sit ahead of the live one
with its start marker intact but its opening brace overwritten.
Matching braces backward from that copy walks into binary garbage and
seeds at a stray `{`, so the parse dies ("key must be a string at line
1 column 2") and the scan drops the inventory even though a healthy
copy is in the same buffer.

Accept a candidate brace only when a quote follows it, the shape of a
real JSON object head, and keep trying later marker occurrences until
one qualifies. When none does, seed at the first marker itself and let
the parser rebuild the object head, so a lone headless copy still
yields its inventory.

The marker walk uses `memmem::find` to match the scans earlier in this
branch.

The monitor walked every committed region of the game process every 10
seconds, reading gigabytes to find a blob that usually had not moved
since the last pass. That walk costs the player frames for seconds at a
time, and it ran whether or not the inventory had changed.

Split the cached-address fast path out of capture_all_blobs into
probe_tick, which reads the remembered address and nothing else, and
never falls back to a walk of its own. The monitor polls it every 2 s and
decides for itself when a result is worth escalating: a fresh parse needs
no walk at all, a cache miss with a sync marker walks immediately, and
everything else is rate-limited by walk_is_due.

The marker itself comes from two places. Warframe formats its log lines
in memory well before flushing them to EE.log, and sampling a live client
showed the in-memory copy running 23 s ahead, so probe_tick finds the
newest "OnInventoryResults completed in" line by content in the game's
log buffers, and the existing EE.log tail sets the same flag whenever it
gets there first. Neither is required: every case in walk_is_due has an
interval that fires without a marker, so a missing EE.log or an
unlocatable buffer costs latency only.